/***********************************************************************/
/* Open Visualization Data Explorer                                    */
/* (C) Copyright IBM Corp. 1989,1999                                   */
/* ALL RIGHTS RESERVED                                                 */
/* This code licensed under the                                        */
/*    "IBM PUBLIC LICENSE - Open Visualization Data Explorer"          */
/***********************************************************************/

#include <dxconfig.h>
#include "../base/defines.h"

#ifndef _Command_h
#define _Command_h

#include "Server.h"
#include "List.h"

//
// Class name definition:
//
#define ClassCommand "Command"

//
// Referenced classes:
//
class CommandScope;
class CommandInterface;

//
// Command class definition:
//
class Command : public Server
{
 private:
  //
  // Private class data:
  //
  static boolean CommandClassInitialized;  // Command class initialized?

  //
  // Private member data:
  //
  char* name;           // name of the command
  boolean active;       // is the command active?
  List activateCmds;    // Commands to activate on success
  List deactivateCmds;  // Commands to activate on success
  List autoActivators;  // Commands that automatically
                        // (de)activate this command.
  void addActivator( Command* );
  void removeActivator( Command* );

 protected:
  //
  // Protected member data:
  //
  boolean hasUndo;  // TRUE if this Command supports undo
  List scopeList;   // list of command scopes

  //
  // To be defined by subclasses:
  // This function will be called by execute() function to perform
  // the actual work done by the command.
  // As per the definition of execute(), if available, the CommandInterface
  // that initiated the execution is provided, otherwise ci will be NULL.
  // NULL.  So, if this method uses ci, it may also need to be prepared to
  // handle the case where ci==NULL.
  //
  virtual boolean doIt( CommandInterface* ci ) = 0;

  //
  // To be defined by subclasses:
  //   This function will be called by undo() function to perform
  //   the actual undo work.
  //
  virtual boolean undoIt() = 0;

  //
  // Constructor:
  //   Protected to prevent direct instantiation.
  //
  Command( const char* name, CommandScope* scope, boolean active );

 public:
  //
  // Notification messages:
  //
  static Symbol MsgActivate;
  static Symbol MsgDeactivate;
  static Symbol MsgDisassociate;
  static Symbol MsgBeginExecuting;
  static Symbol MsgEndExecuting;

  //
  // Destructor:
  //
  ~Command();

  //
  // Implementation of registerClient() for this class:
  //   Sends activation/deactivation message to client interfaces
  //   to sync it with the current state of the Command object.
  //
  virtual boolean registerClient( Client* client );

  //
  // Intiates the action or actions supported by this Command object.
  // This function provides the public interface through which
  // any command is executed.  It notifies all clients of the application
  // when the command begins and ends.  If available, then the
  // CommandInterface that initiated the execution is provided, otherwise
  // ci is passed as NULL.
  //
  virtual boolean execute( CommandInterface* ci = NULL );

  //
  // Causes the action initiated by the execute() member function to be
  // reversed. This funciton provides the public interface through
  // which any command is be reversed.
  //
  boolean undo();

  //
  // Enables the command and any user interface component associated
  // with this Command object.  Command objects can be executed only
  // if they are enabled.
  //
  virtual void activate();

  //
  // Disables the command and any user interface component associated
  // with this Command object.
  //
  virtual void deactivate( const char* reason = NULL );

  //
  // Registers a new scope to this command.
  //   Returns TRUE if successful; FALSE, otherwise.
  //
  virtual boolean registerScope( CommandScope* scope );

  //
  // Unregisters a scope from this command.
  //   Returns TRUE if successful; FALSE, otherwise.
  //
  virtual boolean unregisterScope( CommandScope* scope );

  //
  // Returns active status.
  //
  boolean isActive()
  {
    return this->active;
  }

  //
  // Returns undo capability status.
  //
  boolean canUndo()
  {
    return this->hasUndo;
  }

  //
  // Functions to append a command to either the activation or deactivation
  // list.
  //
  void autoActivate( Command* c );
  void autoDeactivate( Command* c );
  void removeAutoCmd( Command* c );

  //
  // Returns the command name.
  //
  const char* getName()
  {
    return this->name;
  }

  //
  // Returns a pointer to the class name.
  //
  const char* getClassName()
  {
    return ClassCommand;
  }
};

#endif  // _Command_h
